package com.plian.Tools;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.List;
import java.util.Optional;

/**
 * @description:
 * @author: gangan
 * @create: 2020-06-03 14:12
 */
public class BigDecimalUtil {

    /**
     * 相加
     * @param a
     * @param b
     * @return
     */
    public static BigDecimal add(BigDecimal a, BigDecimal b){
        if (!Optional.ofNullable(a).isPresent()){
            return b;
        }
        if (!Optional.ofNullable(b).isPresent()){
            return a;
        }
        return a.add(b);
    }

    /**
     * Integer相加
     * @param a
     * @param b
     * @return
     */
    public static Integer integerAdd(Integer a, Integer b){
        if (!Optional.ofNullable(a).isPresent()){
            return b;
        }
        if (!Optional.ofNullable(b).isPresent()){
            return a;
        }
        return a + b;
    }

    /**
     * 除
     * @param dividend
     * @param divisor
     * @param scale
     * @param roundingMode
     * @return
     */
    public static BigDecimal divide(BigDecimal dividend, BigDecimal divisor, int scale, int roundingMode) {
        if (Optional.ofNullable(dividend).isPresent() && Optional.ofNullable(divisor).isPresent() && divisor.compareTo(BigDecimal.ZERO) != 0){
            return dividend.divide(divisor, scale, roundingMode);
        }
        return null;
    }

    /**
     * 除
     * @param dividend
     * @param divisor
     * @param scale
     * @param roundingMode
     * @param power 倍率
     * @return
     */
    public static BigDecimal divide(BigDecimal dividend, BigDecimal divisor, int scale, int roundingMode, int power) {
        if (Optional.ofNullable(dividend).isPresent() && Optional.ofNullable(divisor).isPresent() && divisor.compareTo(BigDecimal.ZERO) != 0){
            return new BigDecimal(power).multiply(dividend).divide(divisor, scale, roundingMode);
        }
        return null;
    }

    /**
     * 乘 a或b为null返回0
     * @param a
     * @param b
     * @return
     */
    public static BigDecimal multiply(BigDecimal a, BigDecimal b){
        if (!Optional.ofNullable(a).isPresent() || !Optional.ofNullable(b).isPresent()){
            return new BigDecimal(0);
        }
        return a.multiply(b);
    }

    /**
     * 相减
     * @param a
     * @param b
     * @return
     */
    public static BigDecimal subtract(BigDecimal a, BigDecimal b){
        if (!Optional.ofNullable(a).isPresent() && !Optional.ofNullable(a).isPresent()){
            return null;
        }
        if (!Optional.ofNullable(a).isPresent()){
            return new BigDecimal(0).subtract(b);
        }

        if (!Optional.ofNullable(b).isPresent()){
            return a;
        }
        return a.subtract(b);
    }

    /**
     * 转字符串
     * @param bigDecimal
     * @return
     */
    public static String toString(BigDecimal bigDecimal){
        if (bigDecimal == null){
            return null;
        }
        return bigDecimal.toString();
    }

    /**
     * 转字符串
     * @param bigDecimal
     * @param isRetainDecimal 是否保留下小数
     * @return
     */
    public static String toString(BigDecimal bigDecimal, boolean isRetainDecimal){
        if (bigDecimal == null){
            return null;
        }
        String str = bigDecimal.toString();
        if (!isRetainDecimal &&  str.contains(".")){
            str  = str.split("\\.")[0];
        }
        return str;
    }

    public static String toPlanString(BigDecimal bigDecimal){
        if (bigDecimal == null){
            return "";
        }
        return bigDecimal.toPlainString();
    }

    public static double toDoubleValue(BigDecimal bigDecimal){
        if (bigDecimal == null){
            return 0;
        }
        return bigDecimal.doubleValue();
    }

    /**
     * 字符串转
     * @param str
     * @return
     */
    public static BigDecimal toBigdecimal(String str){
        if (StringUtil.isBlank(str)){
            return null;
        }
        try {
            return new BigDecimal(str);
        }catch (Exception e){
            return null;
        }
    }

    /**
     * String to Integer 忽略小数
     * @param str
     * @return
     */
    public static Integer toIntegerIgnoreDecimal(String str){
        if (StringUtil.isBlank(str)){
            return null;
        }
        try {
            if (str.contains(StringPool.DOT)){
                str = str.substring(0, str.indexOf(StringPool.DOT));
            }
            return new Integer(str);
        }catch (Exception e){
            return null;
        }
    }

    public static BigDecimal replaceCommaToBigDecimal(String str){
        if (StringUtil.isBlank(str)){
            return null;
        }
        str = str.replace(",", "").replace("，", "");
        try {
            return new BigDecimal(str);
        }catch (Exception e){
            return null;
        }
    }

    /**
     * 数据保留scale位小数点
     * @param str
     * @param scale
     * @return
     */
    public static String toShortString(String str, int scale){
        if (StringUtil.isBlank(str)){
            return null;
        }
        try {
            BigDecimal decimal = new BigDecimal(str);
            return decimal.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue() + "";
        }catch (Exception e){
            return null;
        }
    }

    /**
     * 数据保留scale位小数点
     * @param decimal
     * @param scale
     * @return
     */
    public static String toShortString(BigDecimal decimal, int scale){
        if (decimal == null){
            return null;
        }
        try {
            String formatStr = "0.";
            for(int i = 0; i < scale; i++){
                formatStr = formatStr + "0";
            }
            return new DecimalFormat(formatStr).format(decimal.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue());
        }catch (Exception e){
            return null;
        }
    }

    /**
     * 判断数字是否为0
     * @param decimal
     * @return
     */
    public static boolean isZero(BigDecimal decimal){
        if(Optional.ofNullable(decimal).isPresent()&&decimal.compareTo(new BigDecimal(0))==0){
            return true;
        }else{
            return false;
        }
    }

    public static BigDecimal objectToBigDecimal(Object value){
        if (value != null){
            if (value instanceof Integer){
                return new BigDecimal((Integer)value);
            }
            if (value instanceof Double){
                return new BigDecimal((Double)value);
            }
            if (value instanceof Float){
                return new BigDecimal((Float)value);
            }
            if (value instanceof String){
                return new BigDecimal((String) value);
            }
            if (value instanceof BigDecimal){
                return (BigDecimal) value;
            }
        }
        return null;
    }

    /**
     * @Author: Take-off
     * @Description: //TODO BigDecimal 数组求和
     * @Date: 3:53 PM 2023/2/13
     * @Param: [bigDecimals]
     * @return: java.math.BigDecimal
     **/
    public static BigDecimal addBigDecimals(List<BigDecimal> bigDecimals){
        BigDecimal bigDecimal = BigDecimal.ZERO;
        if (CollectionUtil.isNotEmpty(bigDecimals)){
            for (BigDecimal decimal:bigDecimals){
                bigDecimal = bigDecimal.add(decimal);
            }
        }
        return bigDecimal;
    }
}
